/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package monitortest;

/**
 *
 * @author the Dope Factory
 */
public class ManagementSerial {
    public static int assorbimentoDetector=0;
    
    public static int sogliaController=0;
    public static int sogliaDetector=655;           //equivalente alla soglia con contratto 3,3kW uguale a 15-16Ah
    
    public static boolean switch1Status=false;
    public static int assorbimentoSwitch1=0;
    public static int assorbimentoSwitch1interrotto=0;
    
    public static boolean switch2Status=false;
    public static int assorbimentoSwitch2=0;
    public static int assorbimentoSwitch2interrotto=0;
    
    
    
    public void analyze(String message){
        char[] temp=null;
        char[] valueTemp=new char[4];
        temp=message.toCharArray();
        int len=temp.length;
        int index=0;
        boolean check=true;                                     //check per do-while
        do{
            switch(temp[index]){                                
                case '@':                                       //ASSORBIMENTO DETECTOR
                    index++;
                    switch(temp[index]){
                        case 'R':                                 //Richiesta assorbimento detector
                            break;
                        default:                                  //valore assorbimento generale
                            int detectorValue=0;                
                            for(int i=0;i<valueTemp.length;i++){        //salvo in un array temporaneo di 4 caratteri il valore
                                valueTemp[i]=temp[index];               
                                index++;
                            }
                            index--;
                            detectorValue=charToInt(valueTemp);         //appoggio il risultato in int
                            assorbimentoDetector=detectorValue;
                            break;
                    }

                    break;
                //------------------------------------------------------------------    
                case 'A':                                       //SWITCH #1
                    index++;
                    switch(temp[index]){
                        case 'W':                               //OPERAZIONI RELAY
                            index++;
                            switch(temp[index]){
                                case '0':                       //spegnimento relay switch1
                                    switch1Status=false;
                                    break;
                                case '1':                       //attivazione relay switch1
                                    switch1Status=true;
                                    break;
                            }
                            break;
                        case 'R':                               //Richiesta assorbimento da parte della centralina
                            break;
                        default:                                //VALORE ASSORBIMENTO SWITCH #1
                            int switch1Value=0;
//                            index++;
                            for(int i=0;i<valueTemp.length;i++){        //salvo in un array temporaneo di 4 caratteri il valore
                                valueTemp[i]=temp[index];               
                                index++;
                            }
                            index--;
                            switch1Value=charToInt(valueTemp);
                            assorbimentoSwitch1=switch1Value;
                            break;
                    }                
                    break;
                //------------------------------------------------------------------
                case 'a':                                       //switch1 interrotto
                    int switch1ValueOff=0;
                    index++;
                    for(int i=0;i<valueTemp.length;i++){        //salvo in un array temporaneo di 4 caratteri il valore
                        valueTemp[i]=temp[index];
                        index++;
                    }
                    index--;
                    switch1ValueOff=charToInt(valueTemp);
                    assorbimentoSwitch1interrotto=switch1ValueOff;
                    break;
                //------------------------------------------------------------------
                case 'B':
                    index++;
                    switch(temp[index]){
                        case 'W':                               //OPERAZIONI RELAY
                            index++;
                            switch(temp[index]){
                                case '0':                       //spegnimento relay switch2
                                    switch2Status=false;
                                    break;
                                case '1':                       //attivazione relay switch2
                                    switch2Status=true;
                                    break;
                            }
                            break;
                        case 'R':                               //Richiesta assorbimento da parte della centralina
                            break;
                        default:                                //VALORE ASSORBIMENTO SWITCH #2
                            int switch2Value=0;
//                            index++;
                            for(int i=0;i<valueTemp.length;i++){        //salvo in un array temporaneo di 4 caratteri il valore
                                valueTemp[i]=temp[index];               
                                index++;
                            }
                            index--;
                            switch2Value=charToInt(valueTemp);
                            assorbimentoSwitch2=switch2Value;
                            break;
                    }                
                    break;
                //------------------------------------------------------------------
                case 'b':                                       //switch2 interrotto
                    int switch2ValueOff=0;
                    index++;
                    for(int i=0;i<valueTemp.length;i++){        //salvo in un array temporaneo di 4 caratteri il valore
                        valueTemp[i]=temp[index];
                        index++;
                    }
                    index--;
                    switch2ValueOff=charToInt(valueTemp);
                    assorbimentoSwitch2interrotto=switch2ValueOff;
                    break;
                //------------------------------------------------------------------
                case 'C':
                    int sogliaDetectorValue=0;
                    index++;
                    for(int i=0;i<valueTemp.length;i++){        //salvo in un array temporaneo di 4 caratteri il valore
                        valueTemp[i]=temp[index];
                        index++;
                    }
                    index--;
                    sogliaDetectorValue=charToInt(valueTemp);
                    assorbimentoSwitch2interrotto=sogliaDetectorValue;
                    break;
                //------------------------------------------------------------------    
                default:

                    break;
                //__________________________________________________________________     
            }
//            index++;
            if(index >= (len-1)){
                check=false;
            }else{
                index++;
                check=true;
            }
        }while(check);
    }
    
    
    /**
     * Converte un array di char di 4 caratteri massimi in numero intero.
     * Si apette di trovare la cifra più significativa all'indice più basso dell'array di char.
     * ES: numero 1305
     * char[0]='1';
     * char[1]='3';
     * char[2]='0';
     * char[3]='5';
     * 
     * @param values char[4] da convertire.
     * @return Char[] to Integer
     */
    public int charToInt(char[] values){
        int result=((Character.getNumericValue(values[0]))*1000+(Character.getNumericValue(values[1]))*100+
                    (Character.getNumericValue(values[2]))*10+
                    (Character.getNumericValue(values[3])));
        System.out.println("Char to Int: "+result);
        return result;
    }   
}